sensor_base.h File Reference

#include "core/common/wolf.h"
#include "core/sensor/factory_sensor.h"
#include "core/common/node_state_blocks.h"
#include "core/common/time_stamp.h"
#include "yaml-cpp/yaml.h"
#include "yaml-schema-cpp/yaml_schema.hpp"
#include "core/hardware/hardware_base.h"
#include "core/capture/capture_base.h"
#include "core/processor/processor_base.h"

Go to the source code of this file.

Classes
class	wolf::SensorBase

Namespaces
namespace	wolf

Macros
#define	WOLF_SENSOR_CREATE(SensorClass)
#define	WOLF_SENSOR_TEMPLATE_DIM_CREATE(SensorClass, Dim)

Functions
	wolf::WOLF_PTR_TYPEDEFS (SensorBase)

Macro Definition Documentation

WOLF_SENSOR_CREATE

#define WOLF_SENSOR_CREATE

(

SensorClass

)

WOLF_SENSOR_TEMPLATE_DIM_CREATE

#define WOLF_SENSOR_TEMPLATE_DIM_CREATE	(		SensorClass,
			Dim
	)

Value:

    static SensorBasePtr create(const YAML::Node& _input_node, const std::vector<std::string>& _folders_schema = {})  \
    {                                                                                                                 \
        std::shared_ptr<SensorClass> sen;                                                                             \
        if (not _folders_schema.empty())                                                                              \
        {                                                                                                             \
            auto server = yaml_schema_cpp::YamlServer(_folders_schema);                                               \
            server.setYaml(_input_node);                                                                              \
            if (not server.applySchema(#SensorClass + std::to_string(Dim) + "d"))                                     \
            {                                                                                                         \
                WOLF_ERROR(server.getLog());                                                                          \
                return nullptr;                                                                                       \
            }                                                                                                         \
            sen = std::shared_ptr<SensorClass>(new SensorClass<Dim>(server.getNode()));                               \
        }                                                                                                             \
        else                                                                                                          \
            sen = std::shared_ptr<SensorClass>(new SensorClass<Dim>(_input_node));                                    \
        sen->emplacePriors();                                                                                         \
        return sen->shared_from_this_sensor();                                                                        \
    }                                                                                                                 \
    static SensorBasePtr create(const std::string& _yaml_filepath, const std::vector<std::string>& _folders_schema)   \
    {                                                                                                                 \
        auto server = yaml_schema_cpp::YamlServer(_folders_schema, _yaml_filepath);                                   \
        if (not server.applySchema(#SensorClass + std::to_string(Dim) + "d"))                                         \
        {                                                                                                             \
            WOLF_ERROR(server.getLog());                                                                              \
            return nullptr;                                                                                           \
        }                                                                                                             \
        return create(server.getNode(), {});                                                                          \
    }